package net.edu_soft.ec.common.util;


import net.edu_soft.ec.asset.pojo.UserInfo;
import net.edu_soft.ec.common.exception.OperationException;
import net.edu_soft.ec.common.exception.ParameterException;

import javax.servlet.http.HttpSession;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *  @author: PUING
 *  @Date: 2020/3/26 22:24
 *  @Description: 工具类
 */
public class EduCloudsUtils {

    /**
     * 提取出含有产品分类id的产品id
     * @param productTypeId 产品id
     * @param map key:产品id，value：产品分类id集合
     * @return 产品id集合
     */
    public static List<Integer> existsId(Integer productTypeId,Map<Integer, String> map){
        List<Integer> list = new ArrayList<Integer>();
        //遍历
        for (Map.Entry<Integer, String> m : map.entrySet()) {
            //提取出产品分类id集合
            List<Integer> ids = PuingUtil.getNumber(m.getValue());
            //遍历id集合
            for (Integer i : ids) {
                //比较
                if(productTypeId==i) {
                    //将产品id放进集合
                    list.add(m.getKey());
                    continue;
                }

            }
        }
        return list;
    }


    /**
     * map按value值排序
     * @param <K> key值
     * @param <V> 要排序的值
     * @param map 数据
     * @return 排序后的map
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map){
        //转化为list集合
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>( map.entrySet() );
        //调用排序方法
        Collections.sort( list, new Comparator<Map.Entry<K, V>>() {
            public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2 ){
                //o1在前降序，反之则升序
                return (o2.getValue()).compareTo( o1.getValue() );
            }
        } );
        //转换回map
        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list){
            result.put( entry.getKey(), entry.getValue() );
        }
        return result;
    }


    /**
     * java统计List集合中每个元素出现的次数 例如frequencyOfListElements(["1,2,3","1,2,","2,3"])
     * 则返回Map {"1"=2,"2"=3,"3"=2}
     * @param ids 需要排序的
     * @return 排序完整的map
     */
    public static Map<Integer, Integer> frequencyOfListElements(List<String> ids) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (String string : ids) {
            List<Integer> items = extractNumber(string);
            if (items == null || items.size() == 0)
                return null;
            for (Integer temp : items) {
                Integer count = map.get(temp);
                map.put(temp, (count == null) ? 1 : count + 1);
            }
        }
        return map;
    }

    /**
     * @Description: 截取字符串并提取数字
     * @param str 带数字的字符串
     * @return 提取后的整数集合
     */
    public static List<Integer> extractNumber(String str) {
        List<Integer> list = new ArrayList<Integer>();
        String regEx = "[^0-9]";
        Pattern p = Pattern.compile(regEx);
        String[] strs = str.split(",");
        for (int i = 0, len = strs.length; i < len; i++) {
            Matcher m = p.matcher(strs[i].toString());
            list.add(Integer.parseInt(m.replaceAll("").trim()));
        }
        return list;
    }

    /**
     * 根据id集合转化为字符串，以英文“ , ”分隔
     * @param ids id集合
     * @return 转化后的字符串
     */
    public static String convertIds(List<Integer> ids) {
        StringBuffer sb = new StringBuffer();
        for (Integer id : ids) {
            sb.append(id + ",");
        }
        return sb.toString();
    }

    /***
     * 判断是否存在重复的数值
     * @param array 数值集合
     */
    public static void cheakNumbers(List<Integer> array) {
        HashSet<Integer> hashSet = new HashSet<Integer>();
        for (int i = 0; i < array.size(); i++) {
            hashSet.add(array.get(i));
        }
        if (hashSet.size() != array.size()) {
            throw new ParameterException("参数重复，请检查是否重复提交");

        }
    }

    /***
     * 判断数组中是否存在该值
     * @param array 数值集合
     * @param number 校验值
     */
    public static boolean cheakNumbers(List<Integer> array,Integer number) {
        boolean flag= false;
        for (Integer id: array) {
            if(id==number){
                flag=true;
            }
        }
        return flag;
    }

    /***
     * 删除某个值
     * @param ids id串
     * @param id 被删除的id
     * @return 是否存在或删除成功和删除后的集合
     */
    public static List<Integer> delValue(String ids,Integer id){
        //提取id
        List<Integer> idList = PuingUtil.getNumber(ids);
        //转换
        LinkedList<Integer> idLink = new LinkedList<Integer>(idList);
        //迭代器遍历
        Iterator<Integer> itr = idLink.iterator();
        while(itr.hasNext()) {
            //存在就删除
            if(itr.next()==id){
                itr.remove();
                //确认值为1
            }
        }
        return new ArrayList<>(idLink);
    }

    /***
     * 获取用户信息
     * @param httpSession
     * @return
     */
    public static UserInfo getUserInfo(HttpSession httpSession){
        UserInfo user = (UserInfo) httpSession.getAttribute("userInfo");
        if(user==null){
            throw new OperationException("非法用户或用户未登录！请先登录");
        }
        return user;
    }


}